import { rest } from "lodash"
import { HMS_daxiao } from '@/libs/tools'
/*
 * @Description:
 * @Version: 2.0
 * @Autor: huangfu
 * @Date: 2020-09-14 16:21:22
 * @LastEditors: huangfu
 * @LastEditTime: 2020-10-26 10:39:43
 */
export default {

    userStatus: {
        1: '启用',
        2: '停用',
        3: '拉黑',
        4: '注销'
    },

    userType: {
        1: '平台用户',
        2: '对接用户',
        3: '注册用户'
    },
    userFlag: {
        true: '启用',
        false: '禁用'
    },
    // 校验新能源
    validateNewEnergy: (rule, value, callback, _this) => {

    },
    // 校验‘单位’
    validateCompany: (rule, value, callback, _this) => {
        var reg = /^[1-9]\d*$/
        if (!reg.test(value)) {
            callback('请输入正整数')
        } else {
            callback()
        }
    },

    validateMerchantName: (rule, value, callback) => {
        let reg = /^[\u4E00-\u9FA5A-Za-z]*$/
        if (!reg.test(value)) {
            callback('只能输入英文、中文')
        } else {
            callback()
        }
    },
    // 验证type 1 图片
    validateTypeOne: (rule, value, callback) => {
        callback(value)
    },
    // 不能为空格
    validateTrim: (rule, value, callback) => {
        let reg = /^[^\s]*$/g
        if (!reg.test(value)) {
            callback('不能输入空格')
        } else {
            callback()
        }
    },
    // 银行卡号
    validateBankCard: (rule, value, callback) => {
        let reg = /^([1-9]{1})(\d{11}|\d{15}|\d{16}|\d{17}|\d{18})$/g
        if (!reg.test(value)) {
            callback('请输入正确的银行卡号')
        } else {
            callback()
        }
    },
    // 0-99数字
    validateDays: (rule, value, callback) => {
        let reg = /^[0-9]{0,1}[0-9]{0,1}$/
        if (!reg.test(value)) {
            callback('请输入0-99的数字')
        } else {
            callback()
        }
    },
    // 0-14数字
    validateNumr: (rule, value, callback) => {
        let reg = /^([1-9]{0,1}|1[0-4]{0,1})$/
        if (!Number.isInteger(value)) {
            callback('请输入数字')
        } else if (!reg.test(value)) {
            callback('请输入1-14以内天数')
        } else {
            callback()
        }
    },
    // 1-12 月份
    validateMonths: (rule, value, callback, maxMonth) => {
        let reg = /^(?:1[0-2]|[1-9])$/
        if (!reg.test(value)) {
            callback('请输入1-12的数字')
        } else if (maxMonth < value) {
            callback('开始月份要小于结束月份')
        } else {
            callback()
        }
    },
    // 验证minDays
    validateMinDays: (rule, value, callback, maxDays, msg) => {
        var reg = /^[1-9]\d*$/
        if (!reg.test(value)) {
            callback('请输入正整数')
        } else if (Number(value) > Number(maxDays)) {
            callback(msg)
        } else {
            callback()
        }
    },
    // 验证maxDays
    validateMaxDays: (rule, value, callback, val, msg) => {
        var reg = /^[1-9]\d*$/
        if (!reg.test(value)) {
            callback('请输入正整数')
        } else if (Number(val) > Number(value)) {
            callback(msg)
        } else {
            callback()
        }
    },
    // 验证minMonth
    validateMinMonths: (rule, value, callback, maxMonth) => {
        let reg = /^(?:1[0-2]|[1-9])$/
        if (!reg.test(value)) {
            callback('请输入1-12的数字')
        } else if (Number(value) >= Number(maxMonth)) {
            callback('开始月份要小于结束月份')
        } else {
            callback()
        }
    },
    // 验证maxMonth
    validateMaxMonths: (rule, value, callback, minMonth) => {
        let reg = /^(?:1[0-2]|[1-9])$/
        if (!reg.test(value)) {
            callback('请输入1-12的数字')
        } else if (Number(minMonth) >= Number(value)) {
            callback('结束月份要大于开始月份')
        } else {
            callback()
        }
    },
    // 用户名验证是否数字开头
    validateNum: (rule, value, callback) => {
        let reg = /^[\d].+$/
        if (reg.test(value)) {
            callback('2-32位，可以包含字母、汉字、数字或@字符，且不以数字开头')
        } else {
            callback()
        }
    },
    // 用户管理 用户名只能输入数字、英文、@、中文
    validateCha: (rule, value, callback) => {
        let reg = /^[^0-9][\u4E00-\u9FA5A-Za-z0-9_\@]+$/
        if (!reg.test(value)) {
            callback('2-32位，可以包含字母、汉字、数字或@字符，且不以数字开头')
        } else {
            callback()
        }
    },
    // 匹配中国大陆手机号
    validatePhone: (rule, value, callback) => {
        let reg = /^1(3[0-9]|4[01456879]|5[0-35-9]|6[2567]|7[0-8]|8[0-9]|9[0-35-9])\d{8}$/
        if (value == null || value == '') {
            callback()
        } else if (!reg.test(value)) {
            callback('请输入正确的手机号')
        } else {
            callback()
        }
    },
    // 电子邮件
    validateEmail: (rule, value, callback) => {
        let reg = /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/
        if (!reg.test(value)) {
            callback('请输入正确的邮箱')
        } else {
            callback()
        }
    },
    // 密码只能输入数字、英文字母、特殊字符，非空格
    validatePwd: (rule, value, callback) => {
        let reg = /^[^\s\u4E00-\u9FA5]*$/
        if (!reg.test(value)) {
            callback('请输入密码')
        } else {
            callback()
        }
    },
    // 密码只能输入数字、英文字母、特殊字符，非空格
    chepai: (rule, value, callback, _this) => {
        if (_this.ruleNumg < 3) {
            _this.ruleNumg++;
            callback()
        }
        console.log(1111111)
        let reg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
        if (!reg.test(_this.obj.msg + _this.obj.zimu + _this.obj.ins)) {
            callback('请输入正确车牌号')
        } else {
            callback()
        }
    },
    // 密码只能输入数字、英文字母、特殊字符，非空格
    validateChildUser: (rule, value, callback) => {
        let reg = /[^\d]/g
        if (reg.test(value)) {
            callback('只能输入数字')
        } else {
            callback()
        }
    },
    // 验证身份证号
    validateIdCard: (rule, value, callback) => {
        let reg = /(^\d{15}$)|(^\d{17}([0-9]|X)$)/g
        if (!reg.test(value)) {
            callback('请输入正确的身份证号')
        } else {
            callback()
        }
    },
    /**
     * @param { 部门管理 }
     */
    // 匹配名称 中文、英文、数字，位数限制16位以内
    validateDeptName: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]{1,16}$/g
        if (!reg.test(value)) {
            callback('16位以内，可以包含字母、汉字、数字')
        } else {
            callback()
        }
    },
    // 匹配角色编码 英文、数字，特殊字符，位数限制32位以内
    validateDeptCode: (rule, value, callback) => {
        let reg = /^[^\s\u4E00-\u9FA5]{1,32}$/g
        if (!reg.test(value)) {
            callback('32位以内，可以包含英文、数字，特殊字符')
        } else {
            callback()
        }
    },
    /**
     * @param { 角色管理 }
     */
    // 匹配名称 中文、英文、数字，位数限制16位以内
    validateRoleName: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]{1,16}$/g
        if (!reg.test(value)) {
            callback('16位以内，可以包含字母、汉字、数字')
        } else {
            callback()
        }
    },
    // 匹配角色编码 英文、数字，特殊字符，位数限制32位以内
    validateRoleCode: (rule, value, callback) => {
        let reg = /^[^\s\u4E00-\u9FA5]{1,32}$/g
        if (!reg.test(value)) {
            callback('32位以内，可以包含英文、数字，特殊字符')
        } else {
            callback()
        }
    },
    /**
     * @param { 个人中心 }
     */
    // 匹配账号 中文、英文、数字，
    validateUserCode: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入账号')
        } else {
            callback()
        }
    },
    // 匹配用户名 中文、英文、数字，
    validateUserName: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入用户名')
        } else {
            callback()
        }
    },
    // 匹配验证码 4位数字
    validateVertify: (rule, value, callback) => {
        let reg = /^[0-9]*$/g
        if (!reg.test(value)) {
            callback('请输入验证码')
        } else {
            callback()
        }
    },
    /**
     * @param { 用户管理-平台角色创建-村务列表 }
     */
    // 匹配名称
    validateCwName: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入名称')
        } else {
            callback()
        }
    },
    // 匹配账号 中文、英文、数字，
    validateZh: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入账号')
        } else {
            callback()
        }
    },
    // 匹配手机号和电话号码
    validateAllPhone: (rule, value, callback, errMsg) => {
        let reg = /^((0\d{2,3}-\d{7,8})|(1(3[0-9]|4[01456879]|5[0-35-9]|6[2567]|7[0-8]|8[0-9]|9[0-35-9])\d{8}))$/g
        if (value == '' || value == null) {
            callback()
        } else if (!reg.test(value)) {
            callback(errMsg || '请输入正确的手机号')
        } else {
            callback()
        }
    },
    /**
     * @param { 万村集市-分类管理 }
     */
    // 匹配分类名称
    validateCtName: (rule, value, callback) => {
        let reg = /^[\n\t]*$/g
        if (reg.test(value)) {
            callback('请输入分类名称')
        } else {
            callback()
        }
    },
    // 匹配账号 中文、英文、数字，
    validateZh: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入账号')
        } else {
            callback()
        }
    },
    /**
     * @param { 商户管理-商户 }
     */
    // 匹配手机号和电话号码
    validateMerPhone: (rule, value, callback) => {
        let reg = /^((0\d{2,3}-{0,1}\d{7,8})|(1(3[0-9]|4[01456879]|5[0-35-9]|6[2567]|7[0-8]|8[0-9]|9[0-35-9])\d{8}))$/g
        if (value == '' || value == null) {
            callback()
        } else if (!reg.test(value)) {
            callback('请输入正确的手机号或座机号')
        } else {
            callback()
        }
    },
    /**
     * @param { 名村管理-攻略管理-文章分类 }
     */
    // 匹配联系人 中文、英文、数字，
    validateCateName: (rule, value, callback) => {
        let reg = /^[^\s]*$/g
        if (!reg.test(value)) {
            callback('请输入分类名称,不能输入空格')
        } else {
            callback()
        }
    },
    /**
     * @param { 产品管理-认养管理-土地管理 }
     */
    validatePole: (rule, value, callback) => {
        var reg = /^(0|\+?[1-9][0-9]{0,4})(\.\d{1,2})?$/
        if (!reg.test(value)) {
            callback('请输入0-99999且保留两位小数')
        } else {
            callback()
        }
    },

    // 匹配账号 中文、英文、数字，
    validateUserCode: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入账号')
        } else {
            callback()
        }
    },
    // 商户端
    /**
     * @param { 商户管理-商户基本信息 }
     */
    // 匹配联系人 中文、英文、数字，
    validateContactName: (rule, value, callback) => {
        let reg = /^[A-Za-z0-9\u4E00-\u9FA5]*$/g
        if (!reg.test(value)) {
            callback('请输入详细地址')
        } else {
            callback()
        }
    },
    validateShMerPhone: (rule, value, callback) => {
        let reg = /^((0\d{2,3}-\d{7,8})|(1(3[0-9]|4[01456879]|5[0-35-9]|6[2567]|7[0-8]|8[0-9]|9[0-35-9])\d{8}))$/g
        if (value == '' || value == null) {
            callback()
        } else if (!reg.test(value)) {
            callback('请输入正确的手机号')
        } else {
            callback()
        }
    },
    /**
     * @param { 营销管理-首页推广-Banner-推广名称 }
     */
    // 推广名称
    validateTgName: (rule, value, callback) => {
        var reg = /^[^\s\d]*$/
        if (!reg.test(value)) {
            callback('请输入推广名称、不能输入数字')
        } else {
            callback()
        }
    },

    /**
     * @param { 匹配数字，可包含两位小数。 }
     */
    validateNumbers: (rule, value, callback, reset) => {
        // 包含0
        var reg = /^\d+(\.\d{1,2})?$/
            // 不包含0
        var regs = /^(([1-9]+(\.\d{1,2})?)|(0\.\d{1,2}))$/
        if (!reg.test(value)) {
            callback('请输入数字且最多两位小数')
        } else {
            callback()
        }
    },
    /**
     * @param { 匹配数字，可包含多位小数。 }
     */
    validateNumberMul: (rule, value, callback) => {
        // 包含0
        var reg = /^\d+(\.\d+)?$/
            // 不包含0
        var regs = /^(([1-9]+(\.\d{1,2})?)|(0\.\d{1,2}))$/
        if (!reg.test(value)) {
            callback('请输入数字且最多两位小数')
        } else {

            callback()
        }
    },
    /**
     * @param { 产品管理-云认养-认养管理-种植管理 }
     */
    // 判断定金是否小于预售价格
    validateDeposit: (rule, value, callback, _this) => {
        if (Number(value) >= Number(_this.obj.price)) {
            callback('定金请设置小于预售价格')
        }
        callback()
    },

    /**
     * @param { 产品管理(商户端)-云认养-认养管理-种植管理-作物管理 }
     */
    // 判断开始月份是否小于结束月份
    validateStartMonth: (rule, value, callback, _this) => {
        if (Number(value) >= Number(_this.obj.endMonth)) {
            callback('开始月份请小于结束月份')
        }
        callback()
    },
    // 判断结束月份是否大于开始月份
    validateEndMonth: (rule, value, callback, _this) => {
        if (Number(value) <= Number(_this.obj.startMonth)) {
            callback('结束月份请大于开始月份')
        }
        callback()
    },
    // 判断开始日期是否小于结束日期
    validateStartDate: (rule, value, callback, _this) => {
        if (Number(value) >= Number(_this.obj.endDate)) {
            callback('开始日期请小于结束日期')
        }
        callback()
    },
    // 判断结束日期是否大于开始日期
    validateEndDate: (rule, value, callback, _this) => {
        if (Number(value) <= Number(_this.obj.startDate)) {
            callback('结束日期请大于开始日期')
        }
        callback()
    },

    /**
     * @param {营销管理-首页推广-banner}
     */
    // 日期校验（结束时间要大于开始时间）
    validateEndTime: (rule, value, callback, _this) => {
        var endTime = new Date(value).getTime()
        var startTime = new Date(_this.obj.startTime).getTime()
        if (endTime < startTime) {
            callback('失效时间请大于生效时间')
        }
        callback()
    },
    // 生效时间请小于失效时间
    validateStartTime: (rule, value, callback, _this) => {
        var endTime = new Date(_this.obj.endTime).getTime()
        var startTime = new Date(value).getTime()
        if (startTime > endTime) {
            callback('生效时间请小于失效时间')
        }
        callback()
    },

    // 匹配正整数
    validatePositiveInteger: (rule, value, callback, _this) => {
        var reg = /^[1-9]\d*$/
        if (!reg.test(value)) {
            callback('请输入正整数')
        } else {
            callback()
        }
    },
    // 匹配正整数和0-999999
    validateZzs: (rule, value, callback, _this, field, index, name) => {
        // var regs = /^(0|[1-9]\d{0,5})(\.\d{1,2})?$/
        // if (regs.test(value)) {
        //     _this['obj'][field][index][name] = 0
        //     callback()
        // }
        let reg = /^([0-9]{0,1}|[1-9]\d{0,5})$/
        if (!reg.test(value)) {
            callback('请输入正整数和0')
        } else {
            callback()
        }
    },
    // 判断是否有两个标签（逗号隔开）
    validateTag: (rule, value, callback, _this) => {
        // var reg = /^(?!.*(，|,).*(,|，))^[^@]*$/
        if (value.indexOf(',') == 0 || value.indexOf('，') == 0) {
            callback('最多输入两个标签,且逗号不能开头')
        }
        var reg = /^[a-zA-Z\d\u4E00-\u9FA5]*(,|，)?[a-zA-Z\d\u4E00-\u9FA5]+$/
        if (!reg.test(value)) {
            callback('最多输入两个标签,且逗号不能结尾')
        } else {
            callback()
        }
    },
    // 判断是否有两个标签（逗号隔开）
    validateTags: (rule, value, callback, _this) => {
        // var reg = /^(?!.*(，|,).*(,|，))^[^@]*$/
        var reg = /^[a-zA-Z\d\u4E00-\u9FA5]{0,4}(,|，)?[a-zA-Z\d\u4E00-\u9FA5]{1,4}$/
        if (value.indexOf(',') == -1 && value.indexOf('，') == -1) {
            var arr = value.split(',').some(el => el.length > 4)
            if (arr) {
                callback('最多输入两个标签(每个标签最多4个字)')
            }
        }
        if (value.indexOf(',') == 0 || value.indexOf('，') == 0) {
            callback('最多输入两个标签(每个标签最多4个字),且逗号不能开头')
        }
        if (!reg.test(value)) {
            callback('最多输入两个标签(每个标签最多4个字),且逗号不能结尾')
        } else {
            callback()
        }
    },
    // 结束时间请小于开始时间
    validateBeginTime: (rule, value, callback, _this, otherFiled, error) => {
        if (_this.obj[otherFiled]) {
            var startTime = new Date(value).getTime()
            var endTime = new Date(_this.obj[otherFiled]).getTime()
            if (startTime > endTime) {
                callback(error || '开始时间请小于结束时间')
            }
        }
        callback()
    },
    // 结束时间请大于开始时间
    validateStopTime: (rule, value, callback, _this, otherFiled, error) => {
        if (_this.obj[otherFiled]) {
            var startTime = new Date(_this.obj[otherFiled]).getTime()
            var endTime = new Date(value).getTime()
            if (endTime < startTime) {
                callback(error || '结束时间请大于开始时间')
            }
        }

        callback()
    },
    // 结束时间请小于开始时间(时分秒)
    validateBeginPickTime: (rule, value, callback, _this, otherFiled, error) => {
        if (_this.obj[otherFiled]) {
            var time = HMS_daxiao(value, _this.obj[otherFiled])
            if (time > 0) {
                callback(error || '开始时间请小于结束时间')
            }
        }
        callback()
    },
    // 结束时间请大于开始时间(时分秒)
    validateStopPickTime: (rule, value, callback, _this, otherFiled, error) => {
        if (_this.obj[otherFiled]) {
            var time = HMS_daxiao(value, _this.obj[otherFiled])
            if (time < 0) {
                callback(error || '结束时间请大于开始时间')
            }
        }
        callback()
    },
    // 年龄限制
    validateMinAge: (rule, value, callback, maxDays) => {
        var reg = new RegExp('^(1[89]|[2-5][0-9]|6[0-5])$', 'gi')
        if (!reg.test(value)) {
            callback('请输入18-65之间的数字')
        }
        if (Number(value) > Number(maxDays)) {
            callback('不能大于截止年龄')
        } else {
            callback()
        }
    },
    // 年龄限制
    validateMaxAge: (rule, value, callback, minDays) => {
        var reg = new RegExp('^(1[89]|[2-5][0-9]|6[0-5])$', 'gi')
        if (!reg.test(value)) {
            callback('请输入18-65之间的数字')
        }
        if (Number(minDays) > Number(value)) {
            callback('不能小于开始年龄')
        } else {
            callback()
        }
    },
    /**
     *
     * @param {活动-活动列表}
     */
    // 匹配名称与说明
    validateMark: (rule, value, callback) => {
        let reg = /^[^\s]*$/
        if (!reg.test(value)) {
            callback('不能输入空格')
        } else {
            callback()
        }
    },
    // 匹配多个标签(只能输入英文逗号、不能开头，不能结尾)
    validateAcTag: (rule, value, callback) => {
        var reg = /^[^,][a-zA-Z\d\u4E00-\u9FA5\,]*[^\@\_\-\,\，]$/
        if (!reg.test(value)) {
            callback('请使用英文逗号分割')
        } else {
            callback()
        }
    },
    // +  1或多
    // ?  0或1

    // 校验数字
    validateNumber: (rule, value, callback, res) => {
        if (!value) {
            callback(new Error('请输入' + res || '职务排序'))
        }
        // 模拟异步验证效果
        if (!Number.isInteger(value)) {
            callback(new Error('请输入数字'))
        } else {
            callback()
        }
    },
    // 校验空格
    validateEmpty: (rule, value, callback) => {
        let reg = /^[^\s]*$/g
        if (!reg.test(value)) {
            callback('不能输入空格')
        } else {
            callback()
        }
    },
    // 消除空格(两个方法都行)
    blurTrim: (_this, obj, name) => {
        if (_this[obj][name]) { _this[obj][name] = _this[obj][name].replace(/[\s]/g, '') }
    },
    // blurTrim: (obj, name) => {
    //     if (obj[name])
    //         obj[name] = obj[name].replace(/[\s]/g, "")
    // },
    // 过滤车牌信息
    validatePlate: (rule, value, callback, _this) => {
        if (
            _this.obj.msg == '' ||
            _this.obj.zimu == '' ||
            _this.obj.ins == '' || _this.obj.ins.length < 5
        ) {
            callback(new Error('请输入5位车牌号'))
        } else {
            callback()
        }
    },
    // 过滤新能源
    validateEnPlate: (rule, value, callback, _this) => {
        if (
            _this.obj.msg == '' ||
            _this.obj.zimu == '' ||
            _this.obj.ins == '' || _this.obj.ins.length < 6
        ) {
            callback(new Error('请输入车牌号'))
        } else {
            callback()
        }
    },
    // 判断日期是否交叉
    validateJx: (rule, value, callback, _this) => {
        var timeSegments = _this.obj.timeNumList.map(el => el.timeRanges.filter(it => it)).filter(it => it.length)
        if (timeSegments.length === 1) callback()

        timeSegments.sort((timeSegment1, timeSegment2) =>
            timeSegment1[0].localeCompare(timeSegment2[0])
        )

        for (let i = 0; i < timeSegments.length - 1; i++) {
            const currentEndTime = timeSegments[i][1]
            const nextStartTime = timeSegments[i + 1][0]

            if (currentEndTime >= nextStartTime) {
                callback('时间不能交叉')
            }
        }

        callback()
    },
    // 比较时分大小(start) 开始时间时分
    compareBeforeTime: (rule, value, callback, _this, otherFiled, error) => {
        //分割开始时间的时
        let kaiShi = value.split(":")[0];
        //分割开始时间的分
        let kaiFen = value.split(":")[1];
        //分割结束时间的时
        let jieShi = _this.obj[otherFiled].split(":")[0];
        //分割结束时间的分
        let jieFen = _this.obj[otherFiled].split(":")[1];
        //判断两者的时
        if (kaiShi < jieShi) {
            callback();
        } else if (kaiShi == jieShi) {
            //如果等于的话就判断两者的分
            if (kaiFen < jieFen) {
                callback()
            } else {
                callback(new Error(error))
            }

        } else {
            callback(new Error(error))
        }
    },
    // 比较时分大小(end) 结束时间时分
    compareEndTime: (rule, value, callback, _this, otherFiled, error) => {
        //分割开始时间的时
        let kaiShi = _this.obj[otherFiled].split(":")[0];
        //分割开始时间的分
        let kaiFen = _this.obj[otherFiled].split(":")[1];
        //分割结束时间的时
        let jieShi = value.split(":")[0];
        //分割结束时间的分
        let jieFen = value.split(":")[1];
        //判断两者的时
        if (kaiShi < jieShi) {
            callback();
        } else if (kaiShi == jieShi) {
            //如果等于的话就判断两者的分
            if (kaiFen < jieFen) {
                callback()
            } else {
                callback(new Error(error))
            }

        } else {
            callback(new Error(error))
        }
    },

}